// @ts-ignore
/* eslint-disable */
import request from '@/utils/request';

/** 新增积分活动 POST /fds/member/addMemActivity */
export async function addMemActivityUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addMemActivityUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_74>('/fds/member/addMemActivity', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增会员 POST /fds/member/addMember */
export async function addMemberUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addMemberUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_8>('/fds/member/addMember', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 会员积分-手动变更 POST /fds/member/addMemberIntegral */
export async function updateIntegralUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateIntegralUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_6>('/fds/member/addMemberIntegral', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增跟进 POST /fds/member/addMemFollow */
export async function addMemFollowUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addMemFollowUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_10>('/fds/member/addMemFollow', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 分配会员 POST /fds/member/assignMember */
export async function assignMemberUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.assignMemberUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/member/assignMember', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 会员积分-删除变更记录 POST /fds/member/deleteMemberIntegral */
export async function deleteIntegralUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.deleteIntegralUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/member/deleteMemberIntegral', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 结束活动 POST /fds/member/endMemActivity */
export async function endMemActivityUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.endMemActivityUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/member/endMemActivity', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出积分活动列表 POST /fds/member/exportMemActivityList */
export async function exportMemActivityListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportMemActivityListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportMemActivityList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出积分活动轮次列表 POST /fds/member/exportMemActivityRoundList */
export async function exportMemActivityRoundListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportMemActivityRoundListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportMemActivityRoundList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出积分活动参与列表 POST /fds/member/exportMemActJoinList */
export async function exportMemActJoinListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportMemActJoinListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportMemActJoinList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出会员 POST /fds/member/exportMember */
export async function exportMemberUsingPOST(options?: { [key: string]: any }) {
  return request<any>('/fds/member/exportMember', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 导出会员归属列表 POST /fds/member/exportMemberAtbList */
export async function exportMemberAtbListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportMemberAtbListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportMemberAtbList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出聊天记录 POST /fds/member/exportMemberChatLogList */
export async function exportMemberChatLogListUsingPOST(options?: { [key: string]: any }) {
  return request<any>('/fds/member/exportMemberChatLogList', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 导出会员列表 POST /fds/member/exportMemberList */
export async function exportMemberListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportMemberListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportMemberList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出会员通知 POST /fds/member/exportMemberMsgList */
export async function exportLosDetailUsingPOST2(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportLosDetailUsingPOST2Params,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportMemberMsgList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出会员待办记录列表 POST /fds/member/exportMemberTodoList */
export async function exportMemberTodoListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportMemberTodoListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportMemberTodoList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出客服经理列表 POST /fds/member/exportServiceManagerList */
export async function exportServiceManagerListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportServiceManagerListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportServiceManagerList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出待办统计列表 POST /fds/member/exportTodoStatisticsList */
export async function exportTodoStatisticsListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportTodoStatisticsListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/exportTodoStatisticsList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取积分活动途径统计列表 POST /fds/member/getActPathTotal */
export async function getActPathTotalUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getActPathTotalUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultActPathTotalDto_>('/fds/member/getActPathTotal', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取积分活动详情 POST /fds/member/getMemActivity */
export async function getMemActivityUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemActivityUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_07>('/fds/member/getMemActivity', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取积分活动列表 POST /fds/member/getMemActivityList */
export async function getMemActivityListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemActivityListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult36>('/fds/member/getMemActivityList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取积分活动轮次列表 POST /fds/member/getMemActivityRoundList */
export async function getMemActivityRoundListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemActivityRoundListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult37>('/fds/member/getMemActivityRoundList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取积分活动参与列表 POST /fds/member/getMemActJoinList */
export async function getMemActJoinListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemActJoinListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultMemActJoinDto_>('/fds/member/getMemActJoinList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员信息 GET /fds/member/getMember */
export async function getMemberUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.MemberDto>('/fds/member/getMember', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员归属列表 POST /fds/member/getMemberAttributionList */
export async function getMemberAttributionListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberAttributionListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult2>('/fds/member/getMemberAttributionList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员信息根据手机号/会员号 GET /fds/member/getMemberByNumber */
export async function getMemberByNumberUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberByNumberUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_8>('/fds/member/getMemberByNumber', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 聊天记录-暂无 POST /fds/member/getMemberChatLogList */
export async function getMemberChatLogListUsingPOST(options?: { [key: string]: any }) {
  return request<API.PageResult6>('/fds/member/getMemberChatLogList', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 获取会员跟进记录列表 POST /fds/member/getMemberFollowUpList */
export async function getMemberFollowUpListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberFollowUpListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult8>('/fds/member/getMemberFollowUpList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员赠送记录列表 POST /fds/member/getMemberGiveList */
export async function getMemberGiveListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberGiveListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult7>('/fds/member/getMemberGiveList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取标签组-会员标签 GET /fds/member/getMemberGroup */
export async function getMemberGroupUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberGroupUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultMemLabelGroupDto_>('/fds/member/getMemberGroup', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员积分记录列表 POST /fds/member/getMemberIntegralList */
export async function getMemberIntegralListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberIntegralListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult5>('/fds/member/getMemberIntegralList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员列表 POST /fds/member/getMemberList */
export async function getMemberListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultMemberDto_>('/fds/member/getMemberList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 会员通知 POST /fds/member/getMemberMsgList */
export async function getMemberMsgListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberMsgListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult9>('/fds/member/getMemberMsgList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员订单列表 POST /fds/member/getMemberOrderList */
export async function getMemOrderListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemOrderListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultMemOrderDto_>('/fds/member/getMemberOrderList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员待办记录列表 POST /fds/member/getMemberTodoList */
export async function getMemberTodoListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemberTodoListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultMemTodoDto_>('/fds/member/getMemberTodoList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取会员预付款记录列表 POST /fds/member/getMemPrepaymentList */
export async function getMemPrepaymentListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMemPrepaymentListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult10>('/fds/member/getMemPrepaymentList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取客服经理列表 POST /fds/member/getServiceManagerList */
export async function getServiceManagerListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getServiceManagerListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult28>('/fds/member/getServiceManagerList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取待办统计列表 POST /fds/member/getTodoStatisticsList */
export async function getTodoStatisticsListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getTodoStatisticsListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult3>('/fds/member/getTodoStatisticsList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 赠送积分 POST /fds/member/giveIntegral */
export async function giveIntegralUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.giveIntegralUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/member/giveIntegral', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导入会员 POST /fds/member/importMember */
export async function importMemberUsingPOST(
  body: {},
  file?: File,
  options?: { [key: string]: any },
) {
  const formData = new FormData();

  if (file) {
    formData.append('file', file);
  }

  Object.keys(body).forEach((ele) => {
    const item = (body as any)[ele];

    if (item !== undefined && item !== null) {
      formData.append(
        ele,
        typeof item === 'object' && !(item instanceof File) ? JSON.stringify(item) : item,
      );
    }
  });

  return request<boolean>('/fds/member/importMember', {
    method: 'POST',
    data: formData,
    requestType: 'form',
    ...(options || {}),
  });
}

/** 合并会员 POST /fds/member/mergeMember */
export async function mergeMemberUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.mergeMemberUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/member/mergeMember', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 开启积分活动 POST /fds/member/startMemActivity */
export async function addMemActivityUsingPOST1(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addMemActivityUsingPOST1Params,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_74>('/fds/member/startMemActivity', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 同步积分 POST /fds/member/syncBigintegral */
export async function syncBigintegralUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.syncBigintegralUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/member/syncBigintegral', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改会员信息 POST /fds/member/updateMember */
export async function updateMemberUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateMemberUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_8>('/fds/member/updateMember', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改会员标签 POST /fds/member/updateMemLabel */
export async function updateMemLabelUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateMemLabelUsingPOSTParams,
  body: API.Pinyin_5[],
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/member/updateMemLabel', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: {
      ...params,
    },
    data: body,
    ...(options || {}),
  });
}

/** 修改客服经理列表 POST /fds/member/updateServiceManagerList */
export async function updateServiceManagerListUsingPOST(
  body: API.ServiceManagerParam,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/member/updateServiceManagerList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
